package com.tedu.API;

import org.junit.Test;

/**
 *Java面向对象---不是真的面向对象---八大基本数据类型
 * 创建对象---类【属性、构造器、方法】
 * 8个包装类: 针对八大基本数据类型提供对应类【方法基本上互通】
 *           不可改变的类
 * 包装类包位置: java.lang
 *
 *   八大数据类型(不是面向对象):      针对八大数据类型对应包装类
 *       int                          Integer  继承Number父类【抽象】
 *       long                         Long     继承Number父类【抽象】
 *       double                       Double   继承Number父类【抽象】
 *       short                        Short    继承Number父类【抽象】
 *       float                        Float   继承Number父类【抽象】
 *       byte                         Byte    继承Number父类【抽象】
 *       char                         Character  继承Object父类
 *       boolean                      Boolean    继承Object父类
 *
 */
public class PackingAPI {
   @Test
    public void test(){
       int a=1;  //不是面向对象，通过.[反射]
       //创建一个int类型对象: Integer构造器: 引入|直接写
       Integer i=new Integer(a);
       i.toString();
   }

    /**
     * 包装类API
     * xxxValue方法    返回值: 对应数据类型
     * 作用: 把包装类转换为基本数据类型的方法
     * 测试:  6个包装类
     */
    @Test
    public void testxxxValue(){
        Integer i=new Integer(2);   //打包: 对应类型放入包装类
        i.intValue() ;    //接受: int类型和Integer
        System.out.println(i);
        //测试其他七个包装类
        String s1="123.123" ;       // Double
        Double d=new Double(123.123);
        d=d.doubleValue();
        System.out.println(d);

        String s2="1"  ;             //Byte
        Byte b=new Byte(s2);
        b=b.byteValue();
        System.out.println(b);

        String s3="123.124F" ;      // Float  对   123.1默认double
        Float f=new Float(s3);
        float f1=f.floatValue();
        System.out.println(f1);
        //包装类构造器: 直接传值， 【使用字符串传值: Long包装认为L字符，并不是数值】
        String s4="1234L" ;
        // Long   输出NumberFormatException异常   数值转换异常
        Long l=new Long(5678L);
        l=l.longValue();
        System.out.println(l);

        String s5="true" ;           //Boolean
        Boolean b1=new Boolean(s5);
         b1=b1 .booleanValue();
        System.out.println(b1);

        char s6='a' ;            //Character
        Character c=new Character(s6);
        c=c.charValue();
        System.out.println(c);

        //Double s1=new Double(123.123);
        //s1.doubleValue();
       // System.out.println(s1);

       // Byte s2=new Byte(1);
       // s2.intValue() ;
        //System.out.println(s2);

        //Float s3=new Float(123.123F);
        //s3.floatValue() ;
        //System.out.println(s3);

        //Long s4=new Long(1234L);
       // s4.longValue() ;
       // System.out.println(s4);

       // Boolean s5=new Boolean(true);
       // s5.booleanValue();
        //System.out.println(s5);

       // Character s6=new Character(a);
       // s6.charValue();
        //System.out.println(s6);
    }

/**
 * 包装类具备静态方法
 * valueOf()     返回值: 对应数据类型
 * 作用: 把包装类转换为基本数据类型的方法
 */
@Test
    public void testValueOf(){
       int i=Integer.valueOf(1);   //打包拆包一体化
       Boolean.valueOf(true);
       char c=Character.valueOf('1');
       Float.valueOf(1.123F);   //1.123默认 double  编译工具
    }

    /**
     * 包装类--------------Servlet[JavaBean==实体类]
     * public class Person{
     *     Integer  id;  //成员变量---解析
     * }
     * parseXXX()     静态方法   返回值: 对应类型
     * 作用: 将获取到的字符串转换为对应类型
     */
    @Test
    public void testParseXXX(){
        String s="123";  //将字符串转换为整型
        int i=Integer.parseInt(s);  //区别: 解析字符串，转换为正确类型
        int is=Integer.valueOf(s); //区别: 存入值，打包拆包获取值
        System.out.println(i);
        System.out.println(i==is);
        //将整型转换为字符串
        String s1=String.valueOf(123);  //与包装类，用法一致，实现不一致
        //自己测: String s2="456f";   char s3='a';
        String s2="456f";
        float f=Float.parseFloat(s2);
        System.out.println(f);
        char s3='a';
        //  Character    没有针对字符解析
    }

    /**
     * 自动拆装箱:
     * JDK1.5之前没有自动拆装箱
     * JDK1.5之后有自动拆装箱     2004
     */
    @Test
    public void testJ(){
        //JDK1.5之前没有自动拆装箱
        Integer in=Integer.valueOf(1);   //装箱
       int ii= in.intValue();   //拆箱
        //JDK1.5之后自动拆箱
        Integer i=1;
        int is=i;
        //编译器帮我们写了拆装箱过程----JVM虚拟机认1.5之前写法
    }
}
